package com.basic.hellorabbit.util;

import com.basic.hellorabbit.dto.UsersDTO;
import com.github.javafaker.Faker;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.stream.Collectors;
/**
* @Description:    操作方法对比
* @Author:         Joe
* @CreateDate:     2020/5/11 17:11
*/
@Slf4j
public class JavaFakerWay {

    /**
     * 使用java faker 创建原始数据集合
     * @return
     */
    public static List<UsersDTO> getList(){
        log.info("使用java faker：创建原始数据集合");
        //设置语言、地区
        Locale locale = new Locale("zh","CN");
        //创建对象
        Faker faker = new Faker(locale);
        Random random = new Random();
        List<UsersDTO> usersDTOS = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            UsersDTO usersDTO = new UsersDTO(faker.name().name(),random.nextInt(20)+15,faker.address().fullAddress(),faker.job().seniority());
            System.out.println(usersDTO);
            usersDTOS.add(usersDTO);
        }
        return usersDTOS;
    }

    /**
     * 1.将原始数据中年龄大于20岁用户过滤出来
     * @param usersDTOS
     * @return
     */
    public static List<UsersDTO> getFor(List<UsersDTO> usersDTOS){
        log.info("for循环：过滤");
        List<UsersDTO> users =null;
        if (usersDTOS != null && usersDTOS.size()>0){
            for (int i = 0; i < usersDTOS.size(); i++) {
                UsersDTO usersDTO = usersDTOS.get(i);
                if (usersDTO.getAge()>20){
                    users.add(usersDTO);
                }
            }
        }
        return users;
    }

    /**
     * 2.Lambda表达式:forEach()进行遍历集合
     * item：可以是任意值。类似于for循环(1)中的循环值(usersDTO)
     * 参数列表 -> 表达式
     * 参数列表 -> {表达式集合}
     * 需要注意 lambda 表达式隐含了 return 关键字，所以在单个的表达式中，无需显式的写 return 关键字，
     * 但是当表达式是一个语句集合的时候则需要显式添加 return 关键字，并用花括号{ } 将多个表达式包围起来
     */
    public static List<UsersDTO> getForEach(List<UsersDTO> usersDTOS){
        log.info("forEach()：过滤");
        List<UsersDTO> users =new ArrayList<>();
        usersDTOS.forEach(item->{
            if (item.getAge()>20){
                users.add(item);
            }
        });
        return users;

    }

    /**
     * 3.Lambda表达式:将过滤出来数据按年龄排序
     * Comparator[带有比较器参数的Sort方法]
     * 语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符。
     * @param filter
     * @return
     */
    public static List<UsersDTO> getSort(List<UsersDTO> filter){
        log.info("Lambda表达式：按年龄排序");
        if (filter != null && filter.size()>0){
            filter.sort((o1,o2)->{
                return o1.getAge()-o2.getAge();
            });
        }
        return filter;
    }

    /**
     * 4.stream()流操作:将usersDTOS中年龄大于20岁用户过滤出来
     * filter(item->{})   其中item为每一项。 按照自己的需求来筛选filter中的数据
     * @param usersDTOS
     * @return
     */
    public static List<UsersDTO> getfilter(List<UsersDTO> usersDTOS){
        log.info("stream()流：过滤");
        List<UsersDTO> filterList = usersDTOS.stream().filter(item->item.getAge()>20).collect(Collectors.toList());
        return filterList;
    }

    /**
     * 5.stream()流操作:将过滤出来数据按年龄排序
     * sorted((第一个对象，第二个对象)->返回值)  （升降序看是第几个对象与第几个对象比较:前-后 即升序）
     * @param filter
     * @return
     */
    public static List<UsersDTO> getsortedList(List<UsersDTO> filter){
        log.info("stream()流：按年龄排序");
        List<UsersDTO> sortedList = filter.stream().sorted((o1,o2)->o1.getAge()-o2.getAge()).collect(Collectors.toList());
        return sortedList;
    }
}
